package gui.menu;

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.MovieClip;
import flash.display.Shape;
import flash.display.Sprite;
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.geom.ColorTransform;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;
import flash.Lib;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.text.TextFormatAlign;
import flash.utils.Timer;

import gui.menu.MainMenuItem;
import gui.menu.MenuItemType;
import gui.menu.MenuItemContainerStyle;

/**
 * ...
 * @author Damien Mabin & Birdy
 */
class MenuItem extends Sprite
{
	public static var MAXMENUHEIGHT		: Float = Lib.current.stage.stageHeight;
									
	public var m_Type								: MenuItemType;
	public var m_Key								: String;
	public var m_Father 							: MenuItem;
	public var m_Collapse(default, null)			: Bool;
	public var m_SaveExtendedState(default, null)	: Bool;
	public var m_Style								: { backgroundColor : UInt, backgroundAlpha : Float, borderColor : UInt, borderAlpha : Float, foregroundColor : UInt, foregroundAlpha : Float};			
	public var m_TextFormat							: TextFormat;
	public var m_IsExtendableArrow					: BitmapData;
	public var m_HaveMoreChild						: Sprite;
	public var m_ContainerStyle 					: MenuItemContainerStyle;
	
	private var m_MainBackground 					: Sprite;
	private var m_Label 							: TextField;
	private var m_SeparatorLine						: Bitmap;
	private var m_Child 							: Array<MenuItem>;
	private var m_FirstChildDisplayed				: Int;				//Identifiant dans le tableau des enfant, du premier élément affiché dans le conteneur. 0 Tant que le conteneur affiche tout ses enfants.
	private var m_TimerForItemMove					: Timer;
	private var m_CurrentArrow						: Sprite;
	private var m_ChildContainer					: Sprite;
	private var m_HaveMoreChildUp					: Sprite;
	private var m_HaveMoreChildDown					: Sprite;
	private var m_OverFG 							: Bitmap;
	private var m_IsExtendedFG						: Bitmap;
	
	// ----------------------------------------------------------------------------------------------------------------------------------------
	// PUBLIC FUNCTIONS
	
	public function new(?f_Type : MenuItemType, ?f_Key : String)
	{
		super();
		m_Type = ((f_Type == null) ? CLASSIC : f_Type);
		m_Father = null;
		m_Key = f_Key;
		m_MainBackground = new Sprite();
		m_TextFormat = new TextFormat();
		m_TimerForItemMove = new Timer(0);
		m_Child = new Array<MenuItem>();
		m_SaveExtendedState = false;
		m_Style = MainMenuItem.DEFAULT_STYLE;
		m_ContainerStyle = CASCADE;
		m_FirstChildDisplayed = 0;
		m_ChildContainer = new Sprite();
		
		this.addChild(m_ChildContainer);		
				
		switch(f_Type)
		{
			case CLASSIC :
				m_ChildContainer.visible = false;
				m_ChildContainer.x = MainMenuItem.TREEITEMWIDTH;
				m_Collapse = true;
				
				// Zone affichée quand on a la souris sur le MenuItem
				m_OverFG = new Bitmap(new BitmapData(MainMenuItem.TREEITEMWIDTH - 2 * MainMenuItem.PADDINGSIZE, MainMenuItem.TREEITEMHEIGHT - 2 * MainMenuItem.PADDINGSIZE, false, m_Style.foregroundColor));
				m_OverFG.alpha = m_Style.foregroundAlpha;
				m_OverFG.x = MainMenuItem.PADDINGSIZE; 
				m_OverFG.y = MainMenuItem.PADDINGSIZE;
				m_OverFG.visible = false;
				this.addChild(m_OverFG);
				
				// Zone affichée quand le MenuItem est extended (dans le cas ou les ChildContainer ne sont pas placés en cascade)
				m_IsExtendedFG = new Bitmap(new BitmapData(MainMenuItem.TREEITEMWIDTH - 2 * MainMenuItem.PADDINGSIZE, MainMenuItem.TREEITEMHEIGHT - 2 * MainMenuItem.PADDINGSIZE, false, m_Style.foregroundColor));
				m_IsExtendedFG.alpha = m_Style.foregroundAlpha;
				m_IsExtendedFG.x = MainMenuItem.PADDINGSIZE; 
				m_IsExtendedFG.y = MainMenuItem.PADDINGSIZE;
				m_IsExtendedFG.visible = false;
				this.addChild(m_IsExtendedFG);
				
				// Contenu, texte :
				m_Label = new TextField();
				m_Label.selectable = false;
				m_Label.autoSize = TextFieldAutoSize.LEFT;
				m_Label.text = f_Key;
				m_Label.setTextFormat(m_TextFormat);
				m_Label.y = (MainMenuItem.TREEITEMHEIGHT / 2) - (m_Label.height / 2);
				m_Label.x = MainMenuItem.PADDINGSIZE;
				this.addChild(m_Label);
				
				// Zone de fond :
				m_MainBackground.addChild(new Bitmap(new BitmapData(MainMenuItem.TREEITEMWIDTH, MainMenuItem.TREEITEMHEIGHT, true, 0x00000000)));
				this.addChild(m_MainBackground);
				
				// Ajout des listener
				m_MainBackground.addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
				m_MainBackground.addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);
				m_MainBackground.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
			
			case MAIN :
			
			case SEPARATOR :
				// Zone de fond :
				UpdateStyle();				
				this.addChild(m_MainBackground);
			
		}
	}
	
	// Ajoute un fils à l'élément
	public function AddItem(f_ChildItem : MenuItem)
	{
		if (Type.enumEq(m_Type, SEPARATOR))
			throw "YOU CAN'T ADD A CHILD TO A SEPARATOR";
		
		f_ChildItem.y = this.y;
		f_ChildItem.m_Father = this;
		f_ChildItem.m_TextFormat = this.m_TextFormat;
		f_ChildItem.m_Style = this.m_Style;		
		f_ChildItem.m_IsExtendableArrow = this.m_IsExtendableArrow;
		f_ChildItem.m_HaveMoreChild = this.m_HaveMoreChild;
		f_ChildItem.m_SaveExtendedState = this.m_SaveExtendedState;
		f_ChildItem.m_ContainerStyle = this.m_ContainerStyle;
		
		f_ChildItem.UpdateStyle();
		
		// Si c'est le premier enfant qu'on ajoute alors on dessine la petite flèche pour dire qu'il y a des enfants et seulement si l'élément est un élément normal (pas pour le mainMenuItem)
		if ((m_Child.length == 0) && Type.enumEq(m_Type, CLASSIC))
		{
			if ((m_CurrentArrow != null) && this.contains(m_CurrentArrow))				// On supprimer l'ancienne flèche si elle avait déjà été dessinée
				this.removeChild(m_CurrentArrow);
			
			m_CurrentArrow = new Sprite();
			m_CurrentArrow.addChild(new Bitmap(m_IsExtendableArrow));
			m_CurrentArrow.x = m_MainBackground.width - (m_IsExtendableArrow.width + MainMenuItem.PADDINGSIZE);
			m_CurrentArrow.y = (m_MainBackground.height / 2) - (m_IsExtendableArrow.height / 2);
			this.addChild(m_CurrentArrow);
		}
		
		// Ajoute le treeItem à la liste des enfants
		m_Child.push(f_ChildItem);
		
		// La position de l'élément dans le conteneur est donnée par la position du précédent dans le ChildContainer (0 s'il n'a pas de précédent)
		f_ChildItem.y = (m_Child.length > 1) ? (m_Child[m_Child.length - 2].y + m_Child[m_Child.length - 2].m_MainBackground.height) : 0;
		
		// On update le ChildContainer
		UpdateChildContainer();
	}
	
	// Supprime le MenuItem
	public function RemoveItem()
	{
		if (m_Father != null)
		{
			m_Father.m_Child.remove(this);
			
			if (m_Father.m_ChildContainer.contains(this))
				m_Father.m_ChildContainer.removeChild(this);			
			
			// Met à jour l'affichage du père (le conteneur doit avoir réduit sa taille)
			m_Father.UpdateStyle();
		}
		
		for (i in 0...(this.numChildren))
			removeChild(this.getChildAt(0));
			
		Lambda.iter(m_Child, function(son : MenuItem) { son.RemoveItem(); } );
	}
	
	public function UpdateStyle()
	{
		if (Type.enumEq(m_Type, CLASSIC) || Type.enumEq(m_Type, MAIN))
		{
			if (Type.enumEq(m_Type, CLASSIC))
			{
				m_Label.setTextFormat(m_TextFormat);		
				var labelIsTooBig = (m_Label.textWidth > MainMenuItem.LABELWIDTH - 6); //6 <~=> "...".width
				
				while (m_Label.textWidth > MainMenuItem.LABELWIDTH - 6)
				{
					m_Label.text = m_Label.text.substr(0, m_Label.text.length - 1);
					m_Label.setTextFormat(m_TextFormat);
				}
				if (labelIsTooBig) 
					m_Label.appendText("...");
				
				// On redessine le foreground pour le mouse over et le foreground qui indique si l'item est extended
				m_OverFG.bitmapData = new BitmapData(cast m_OverFG.width, cast m_OverFG.height, false, m_Style.foregroundColor);
				m_OverFG.alpha = m_Style.foregroundAlpha;
				m_IsExtendedFG.bitmapData = new BitmapData(cast m_IsExtendedFG.width, cast m_IsExtendedFG.height, false, m_Style.foregroundColor);
				m_IsExtendedFG.alpha = m_Style.foregroundAlpha;
				
				if (m_Child.length > 0)
				{
					// On supprimer l'ancienne flèche si elle avait déjà été dessinée
					if ((m_CurrentArrow != null) && this.contains(m_CurrentArrow))
						this.removeChild(m_CurrentArrow);
					
					m_CurrentArrow = new Sprite();
					m_CurrentArrow.addChild(new Bitmap(m_IsExtendableArrow));
					m_CurrentArrow.x = m_MainBackground.width - (m_IsExtendableArrow.width + MainMenuItem.PADDINGSIZE);
					m_CurrentArrow.y = (m_MainBackground.height / 2) - (m_IsExtendableArrow.height / 2);
					this.addChild(m_CurrentArrow);
				}
			}
			
			UpdateChildContainer();
			
			if ((m_ChildContainer.numChildren == m_Child.length) && (m_HaveMoreChildDown != null) && (m_HaveMoreChildUp != null))
			{
				// Le conteneur est assez grand pour afficher tous les enfants or les Sprite pour scroller sont toujours présents. Il faut donc les enlever et supprimer les listener de scroll.
				this.removeChild(m_HaveMoreChildDown);
				m_HaveMoreChildDown.removeEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);
				m_HaveMoreChildDown = null;
				this.removeChild(m_HaveMoreChildUp);
				m_HaveMoreChildUp.removeEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);
				m_HaveMoreChildUp = null;
				m_ChildContainer.removeEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);				
			}
		}
		else if (Type.enumEq(m_Type, SEPARATOR))
		{
			//Enlève le bitmap contenant la ligne si il existe
			if (m_MainBackground.numChildren > 0)
				m_MainBackground.removeChild(m_SeparatorLine);
				
			var lineFond = new BitmapData(MainMenuItem.TREEITEMWIDTH, MainMenuItem.SEPARATORHEIGHT, true, m_Style.backgroundColor); //BitmapData contenant la ligne
			
			var line = new Shape();
			line.graphics.beginFill(m_Style.backgroundColor, m_Style.backgroundAlpha);
			line.graphics.lineStyle(1, m_Style.borderColor, m_Style.borderAlpha); //Donne à la ligne le même style que celui de la bordure des conteneurs
			line.graphics.moveTo(MainMenuItem.PADDINGSIZE * 2, (MainMenuItem.SEPARATORHEIGHT / 2));
			line.graphics.lineTo(MainMenuItem.TREEITEMWIDTH - (MainMenuItem.PADDINGSIZE * 4), (MainMenuItem.SEPARATORHEIGHT / 2));
			
			//Dessine la ligne dans le BitmapData
			lineFond.draw(line);
			
			m_SeparatorLine = new Bitmap(lineFond);			
			m_MainBackground.addChild(m_SeparatorLine);	//Ajoute la ligne au background du TreeElem
		}
		
		for (child in m_Child)
		{
			child.m_Style = this.m_Style;
			child.UpdateStyle();
		}
	}
	
	public function Expand() : Void
	{
		if (m_Collapse)
		{
			// Collapse l'ensemble des frères de l'élément
			if (m_Father != null)
			{				
				for (i in 0 ... m_Father.m_Child.length)
				{
					if (m_Father.m_Child[i] != this)
					{
						m_Father.m_Child[i].Collapse();
					}
				}
			}			
			
			m_ChildContainer.visible = true;
			if ((m_HaveMoreChildDown != null) && (m_HaveMoreChildUp != null))
				m_HaveMoreChildDown.visible = m_HaveMoreChildUp.visible = true;
				
			m_Collapse = false;
			
			// On marque que l'item est extended
			if (Type.enumEq(m_ContainerStyle, FIXED_ONTOP) && Type.enumEq(m_Type, CLASSIC))
				m_IsExtendedFG.visible = true;
		}
	}
	
	public function Collapse() : Void
	{
		if (!m_Collapse)
		{
			if (!m_SaveExtendedState)
			{
				//Collapse les fils de l'élément
				for (i in 0 ... m_Child.length)
				{
					m_Child[i].Collapse();
				}
			}
			
			m_ChildContainer.visible = false;
			if ((m_HaveMoreChildDown != null) && (m_HaveMoreChildUp != null))
				m_HaveMoreChildDown.visible = m_HaveMoreChildUp.visible = false;
			
			m_Collapse = true;
			
			if (Type.enumEq(m_ContainerStyle, FIXED_ONTOP) && Type.enumEq(m_Type, CLASSIC) && m_IsExtendedFG.visible)
				m_IsExtendedFG.visible = false;
		}
	}
	
	// Retourne le nom complet de l'élément soit la concaténation des m_Key de tous ses ancêtres (séparés par des .)
	public function GetFullKey() : String
	{
		if (m_Father == null)
			return m_Key;
		else
			return m_Father.GetFullKey() + "." + m_Key;
	}
	
	// ----------------------------------------------------------------------------------------------------------------------------------------
	// PRIVATE FUNCTIONS
	
	private function mouseOverHandler(f_ME : MouseEvent) : Void
	{
		m_OverFG.visible = true;
    }
	
	private function mouseOutHandler(f_ME : MouseEvent) : Void
	{
		m_OverFG.visible = false;
    }
	
	private function mouseDownHandler(f_ME : MouseEvent) : Void
	{
		if (m_Child.length > 0)
		{
			if (m_Collapse)
			{
				Expand();
			}
			else
			{
				Collapse();
			}
		}
    }
	
	// Update l'affichage du conteneur d'enfants
	private function UpdateChildContainer()
	{
		if (m_Child.length > 0)
		{
			// Place le conteneur au bon endroit
			if (Type.enumEq(m_ContainerStyle, CASCADE))
				m_ChildContainer.y = 0 + (((m_HaveMoreChildDown == null) && (m_HaveMoreChildUp == null)) ? 0 : m_HaveMoreChild.height - 1);
			else
				m_ChildContainer.y = -this.y + (((m_HaveMoreChildDown == null) && (m_HaveMoreChildUp == null)) ? 0 : m_HaveMoreChild.height - 1);
			
			// La hauteur maximum est donnée par MAXMENUHEIGHT, moins les hauteurs des 2 Sprites indiquant la présence d'enfant cachés, moins l'emplacement ou se situe l'origine dans le stage du menuItem
			var maxHeight = MAXMENUHEIGHT - 2 * m_HaveMoreChild.height - this.localToGlobal(new Point()).y;
			
			var lastChild = m_Child[m_Child.length - 1];
			var lastChildHeight = Std.int(m_ChildContainer.localToGlobal(new Point(0, lastChild.y)).y + lastChild.m_MainBackground.height);
			
			// Update l'affichage de l'ExpendShadow si on est sur le MainMenuItem
			if (Type.enumEq(m_Type, MAIN))
			{
				if (cast(this, MainMenuItem).m_ExpendShadow != null) // Si on n'a pas voulu gérer la m_ExpendShadow, celle-ci est encore null
				{
					var shadowHeight = Std.int(lastChild.y + lastChild.m_MainBackground.height);
					cast(this, MainMenuItem).m_ExpendShadow.bitmapData = new BitmapData(cast cast(this, MainMenuItem).m_ExpendShadow.width, shadowHeight, false, 0x111111);
				}
			}
			
			if (lastChildHeight >= maxHeight) // L'item descend plus bas que la hauteur autorisée
			{
				//if ((m_ChildContainer.y - lastChild.m_MainBackground.height) < m_HaveMoreChild.height) // Le ChildContainer est trop grand même si on l'allonge vers le haut
				//{				
					if ((m_HaveMoreChildDown == null) && (m_HaveMoreChildUp == null))
					{
						m_ChildContainer.y += m_HaveMoreChild.height - 1;
						
						// On n'a pas encore dessiné les shapes indiquant la présence de plus d'éléments que l'on ne peut en afficher
						var imgCartridge = new BitmapData(cast m_HaveMoreChild.width, cast m_HaveMoreChild.height, true, 0x000000);
						imgCartridge.draw(m_HaveMoreChild);
						
						m_HaveMoreChildUp = new Sprite();					
						m_HaveMoreChildUp.addChild(new Bitmap(imgCartridge));
						m_HaveMoreChildUp.rotation = 180;
						m_HaveMoreChildUp.x = m_ChildContainer.x + m_HaveMoreChild.width; // La rotation décale le bitmap d'une largeur vers la gauche
						m_HaveMoreChildUp.y = m_ChildContainer.y + 1;
						m_HaveMoreChildUp.addEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);
						m_HaveMoreChildUp.visible = false;
						this.addChild(m_HaveMoreChildUp);
						
						m_HaveMoreChildDown = new Sprite();
						m_HaveMoreChildDown.addChild(new Bitmap(imgCartridge));
						m_HaveMoreChildDown.x = m_ChildContainer.x;
						m_HaveMoreChildDown.y = m_ChildContainer.y + (m_Child[m_Child.length - 2].y + m_Child[m_Child.length - 2].m_MainBackground.height);
						m_HaveMoreChildDown.addEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);
						m_HaveMoreChildDown.visible = false;
						this.addChild(m_HaveMoreChildDown);
					}
					
					// Listener pour le déroulement des enfants
					m_ChildContainer.addEventListener(MouseEvent.MOUSE_MOVE, ScrollChildContainer);
				//}
				/*else // On remonte vers le haut le ChildContainer, de la hauteur du nouvel élément
				{
					m_ChildContainer.y -= lastChild.m_MainBackground.height;
					
					m_ChildContainer.addChild(lastChild);
				
					// Redessine le fond du conteneur des enfants
					m_ChildContainer.graphics.clear();
					m_ChildContainer.graphics.beginFill(m_Style.backgroundColor, m_Style.backgroundAlpha);
					m_ChildContainer.graphics.lineStyle(1, m_Style.borderColor, m_Style.borderAlpha);
					m_ChildContainer.graphics.drawRect(0, 0, MainMenuItem.TREEITEMWIDTH, (lastChild.y + lastChild.m_MainBackground.height));
				}*/
			}
			else
			{
				if(!m_ChildContainer.contains(lastChild))
					m_ChildContainer.addChild(lastChild);
				
				// Redessine le fond du conteneur des enfants
				m_ChildContainer.graphics.clear();
				m_ChildContainer.graphics.beginFill(m_Style.backgroundColor, m_Style.backgroundAlpha);
				m_ChildContainer.graphics.lineStyle(1, m_Style.borderColor, m_Style.borderAlpha);
				m_ChildContainer.graphics.drawRect(0, 0, MainMenuItem.TREEITEMWIDTH, (lastChild.y + lastChild.m_MainBackground.height));
			}
			
			// Réordonne les items dans le conteneur
			ReplaceAllItemInChildContainer();
		}
		else
		{
			m_ChildContainer.graphics.clear();
		}
	}
	
	// Au passage du curseur sur un ChildContainer (ou sur un Sprite HaveMoreChild), pour effecter le scroll des enfants dans le conteneur
	private function ScrollChildContainer(?f_ME : MouseEvent)
	{
		m_TimerForItemMove.reset();
		
		var current = (m_ChildContainer.mouseY - (m_ChildContainer.height / 2)) / (m_ChildContainer.height / 2);
		
		if (current >= 1)
		{
			//Si la souris est située sur le m_HaveMoreChildDown
			m_TimerForItemMove = new Timer(10);
			m_TimerForItemMove.start();
			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemDown);
		}
		else if (current >= (3 / 4)) 
		{
			//Si la souris est située dans le quart bas du ChildContainer
			m_TimerForItemMove = new Timer(30);
			m_TimerForItemMove.start();
			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemDown);
		}
		else if (current >= (2 / 3)) 
		{
			//Si la souris est située dans le tiers bas du ChildContainer
			m_TimerForItemMove = new Timer(120);
			m_TimerForItemMove.start();
			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemDown);
		}
		else if (current <= -1)
		{
			//Si la souris est située sur le m_HaveMoreChildUp
			m_TimerForItemMove = new Timer(10);
			m_TimerForItemMove.start();
			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemUp);
		}
		else if (current <= -(3 / 4))
		{
			//Si la souris est située dans le quart haut du ChildContainer
			m_TimerForItemMove = new Timer(30);
			m_TimerForItemMove.start();
			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemUp);
		}
		else if (current <= -(2 / 3))
		{
			//Si la souris est située dans le tiers haut du ChildContainer
			m_TimerForItemMove = new Timer(120);
			m_TimerForItemMove.start();
			m_TimerForItemMove.addEventListener(TimerEvent.TIMER, GoChildContainerItemUp);
		}
		else
		{
			m_TimerForItemMove.stop();
		}
	}
	
	// Effectue le scroll des MenuItem vers le bas dans le ChildContainer 
	private function GoChildContainerItemDown(f_te : TimerEvent)
	{
		m_TimerForItemMove.reset();
		m_TimerForItemMove.removeEventListener(TimerEvent.TIMER, GoChildContainerItemDown);
		
		//On vérifie que l'on peut encore se déplacer dans le ChildContainer
		if ((m_FirstChildDisplayed + 1) <= (m_Child.length - m_ChildContainer.numChildren))
		{
			m_FirstChildDisplayed++;
			// On descend vers les items les plus en bas : on remove l'item tout en haut et on add l'item tout en bas
			m_ChildContainer.removeChild(m_Child[m_FirstChildDisplayed - 1]);
			m_ChildContainer.addChild(m_Child[(m_FirstChildDisplayed + m_ChildContainer.numChildren)]);			
			
			ReplaceAllItemInChildContainer();
			// Relance la fonction qui gère le scroll
			ScrollChildContainer();
		}
	}
	
	// Effectue le scroll des MenuItem vers le haut dans le ChildContainer 
	private function GoChildContainerItemUp(f_te : TimerEvent)
	{
		m_TimerForItemMove.reset();
		m_TimerForItemMove.removeEventListener(TimerEvent.TIMER, GoChildContainerItemUp);
		
		//On vérifie que l'on peut encore se déplacer dans le ChildContainer
		if ((m_FirstChildDisplayed - 1) >= 0)
		{
			m_FirstChildDisplayed--;
			// On monte vers les items les plus en haut : on remove l'item tout en bas et on add l'item tout en haut 
			m_ChildContainer.removeChild(m_Child[m_FirstChildDisplayed + m_ChildContainer.numChildren]);
			m_ChildContainer.addChild(m_Child[m_FirstChildDisplayed]);
			
			ReplaceAllItemInChildContainer();
			// Relance la fonction qui gère le scroll
			ScrollChildContainer();
		}
	}
	
	// Repositionne les items du childContainer les uns sous les autres en plaçant le FirstDisplay tout en haut
	private function ReplaceAllItemInChildContainer()
	{		
		m_Child[m_FirstChildDisplayed].y = 0;
		for (i in (m_FirstChildDisplayed + 1)...(m_FirstChildDisplayed + m_ChildContainer.numChildren))
		{
			m_Child[i].y = m_Child[i - 1].y + m_Child[i - 1].m_MainBackground.height;
		}		
	}

	
}